JavaScript Async Generator Helpers: Zvládnutie tvorby a správy streamov

Asynchrónne programovanie v JavaScripte sa v priebehu rokov výrazne vyvinulo. S príchodom asynchrónnych generátorov a asynchrónnych iterátorov získali vývojári výkonné nástroje na spracovanie prúdov asynchrónnych dát. Teraz JavaScript Async Generator Helpers ďalej vylepšujú tieto schopnosti a poskytujú zjednodušený a expresívnejší spôsob vytvárania, transformácie a správy asynchrónnych dátových streamov. Tento sprievodca skúma základy pomocníkov pre asynchrónne generátory, ponára sa do ich funkcionalít a demonštruje ich praktické aplikácie na jasných príkladoch.

Pochopenie asynchrónnych generátorov a iterátorov

Predtým, než sa ponoríme do pomocníkov pre asynchrónne generátory, je kľúčové porozumieť základným konceptom asynchrónnych generátorov a asynchrónnych iterátorov.

Asynchrónne generátory

Asynchrónny generátor je funkcia, ktorú je možné pozastaviť a obnoviť, pričom asynchrónne poskytuje (yield) hodnoty. Umožňuje generovať postupnosť hodnôt v priebehu času bez blokovania hlavného vlákna. Asynchrónne generátory sú definované pomocou syntaxe async function*.

Príklad:

async function* generateSequence(start, end) {
  for (let i = start; i <= end; i++) {
    await new Promise(resolve => setTimeout(resolve, 500)); // Simulácia asynchrónnej operácie
    yield i;
  }
}

// Použitie
const sequence = generateSequence(1, 5);

Asynchrónne iterátory

Asynchrónny iterátor je objekt, ktorý poskytuje metódu next(), ktorá vracia promise, ktorý sa vyrieši na objekt obsahujúci nasledujúcu hodnotu v sekvencii a vlastnosť done, ktorá udáva, či bola sekvencia vyčerpaná. Asynchrónne iterátory sa konzumujú pomocou cyklov for await...of.

Príklad:

async function* generateSequence(start, end) {
  for (let i = start; i <= end; i++) {
    await new Promise(resolve => setTimeout(resolve, 500));
    yield i;
  }
}

async function consumeSequence() {
  const sequence = generateSequence(1, 5);
  for await (const value of sequence) {
    console.log(value);
  }
}

consumeSequence();

Predstavenie pomocníkov pre asynchrónne generátory (Async Generator Helpers)

Pomocníci pre asynchrónne generátory (Async Generator Helpers) sú sadou metód, ktoré rozširujú funkcionalitu prototypov asynchrónnych generátorov. Poskytujú pohodlné spôsoby manipulácie s asynchrónnymi dátovými streamami, čím robia kód čitateľnejším a udržiavateľnejším. Títo pomocníci pracujú lenivo (lazily), čo znamená, že spracúvajú dáta len vtedy, keď sú potrebné, čo môže zlepšiť výkon.

Nasledujúce pomocné funkcie pre asynchrónne generátory sú bežne dostupné (v závislosti od JavaScriptového prostredia a polyfillov):

• map
• filter
• take
• drop
• flatMap
• reduce
• toArray
• forEach

Podrobný prieskum pomocníkov pre asynchrónne generátory

1. `map()`

Pomocník map() transformuje každú hodnotu v asynchrónnej sekvencii použitím poskytnutej funkcie. Vracia nový asynchrónny generátor, ktorý poskytuje transformované hodnoty.

Syntax:

asyncGenerator.map(callback)

Príklad: Konverzia streamu čísel na ich druhé mocniny.

async function* generateNumbers(start, end) {
  for (let i = start; i <= end; i++) {
    await new Promise(resolve => setTimeout(resolve, 200));
    yield i;
  }
}

async function processNumbers() {
  const numbers = generateNumbers(1, 5);
  const squares = numbers.map(async (num) => {
    await new Promise(resolve => setTimeout(resolve, 100)); // Simulácia asynchrónnej operácie
    return num * num;
  });

  for await (const square of squares) {
    console.log(square);
  }
}

processNumbers();

Prípad použitia v reálnom svete: Predstavte si načítavanie údajov o používateľoch z viacerých API a potrebu transformovať tieto údaje do konzistentného formátu. map() sa dá použiť na asynchrónne použitie transformačnej funkcie na každý objekt používateľa.

async function* fetchUsersFromMultipleAPIs(apiEndpoints) {
  for (const endpoint of apiEndpoints) {
    const response = await fetch(endpoint);
    const data = await response.json();
    for (const user of data) {
      yield user;
    }
  }
}

async function processUsers() {
  const apiEndpoints = [
    'https://api.example.com/users1',
    'https://api.example.com/users2'
  ];

  const users = fetchUsersFromMultipleAPIs(apiEndpoints);

  const normalizedUsers = users.map(async (user) => {
    // Normalizácia formátu údajov používateľa
    return {
      id: user.userId || user.id,
      name: user.fullName || user.name,
      email: user.emailAddress || user.email
    };
  });

  for await (const normalizedUser of normalizedUsers) {
    console.log(normalizedUser);
  }
}

2. `filter()`

Pomocník filter() vytvára nový asynchrónny generátor, ktorý poskytuje iba tie hodnoty z pôvodnej sekvencie, ktoré spĺňajú zadanú podmienku. Umožňuje vám selektívne zahrnúť hodnoty do výsledného streamu.

Syntax:

asyncGenerator.filter(callback)

Príklad: Filtrovanie streamu čísel tak, aby obsahoval iba párne čísla.

async function* generateNumbers(start, end) {
  for (let i = start; i <= end; i++) {
    await new Promise(resolve => setTimeout(resolve, 200));
    yield i;
  }
}

async function processNumbers() {
  const numbers = generateNumbers(1, 10);
  const evenNumbers = numbers.filter(async (num) => {
    await new Promise(resolve => setTimeout(resolve, 100));
    return num % 2 === 0;
  });

  for await (const evenNumber of evenNumbers) {
    console.log(evenNumber);
  }
}

processNumbers();

Prípad použitia v reálnom svete: Spracovanie streamu záznamov z logu a odfiltrovanie záznamov na základe ich úrovne závažnosti. Napríklad spracovanie iba chýb a varovaní.

async function* readLogFile(filePath) {
  // Simulácia asynchrónneho čítania log súboru riadok po riadku
  const logEntries = [
    { timestamp: '...', level: 'INFO', message: '...' },
    { timestamp: '...', level: 'ERROR', message: '...' },
    { timestamp: '...', level: 'WARNING', message: '...' },
    { timestamp: '...', level: 'INFO', message: '...' },
    { timestamp: '...', level: 'ERROR', message: '...' }
  ];

  for (const entry of logEntries) {
    await new Promise(resolve => setTimeout(resolve, 50));
    yield entry;
  }
}

async function processLogs() {
  const logEntries = readLogFile('path/to/log/file.log');
  const errorAndWarningLogs = logEntries.filter(async (entry) => {
    return entry.level === 'ERROR' || entry.level === 'WARNING';
  });

  for await (const log of errorAndWarningLogs) {
    console.log(log);
  }
}

3. `take()`

Pomocník take() vytvára nový asynchrónny generátor, ktorý poskytuje iba prvých n hodnôt z pôvodnej sekvencie. Je to užitočné na obmedzenie počtu spracovaných položiek z potenciálne nekonečného alebo veľmi veľkého streamu.

Syntax:

asyncGenerator.take(n)

Príklad: Zobratie prvých 3 čísel zo streamu čísel.

async function* generateNumbers(start) {
  let i = start;
  while (true) {
    await new Promise(resolve => setTimeout(resolve, 200));
    yield i++;
  }
}

async function processNumbers() {
  const numbers = generateNumbers(1);
  const firstThree = numbers.take(3);

  for await (const num of firstThree) {
    console.log(num);
  }
}

processNumbers();

Prípad použitia v reálnom svete: Zobrazenie prvých 5 výsledkov vyhľadávania z asynchrónneho vyhľadávacieho API.

async function* search(query) {
  // Simulácia načítania výsledkov vyhľadávania z API
  const results = [
    { title: 'Result 1', url: '...' },
    { title: 'Result 2', url: '...' },
    { title: 'Result 3', url: '...' },
    { title: 'Result 4', url: '...' },
    { title: 'Result 5', url: '...' },
    { title: 'Result 6', url: '...' }
  ];

  for (const result of results) {
    await new Promise(resolve => setTimeout(resolve, 100));
    yield result;
  }
}

async function displayTopSearchResults(query) {
  const searchResults = search(query);
  const top5Results = searchResults.take(5);

  for await (const result of top5Results) {
    console.log(result);
  }
}

4. `drop()`

Pomocník drop() vytvára nový asynchrónny generátor, ktorý preskočí prvých n hodnôt z pôvodnej sekvencie a poskytne zvyšné hodnoty. Je to opak take() a je užitočný na ignorovanie počiatočných častí streamu.

Syntax:

asyncGenerator.drop(n)

Príklad: Vynechanie prvých 2 čísel zo streamu čísel.

async function* generateNumbers(start, end) {
  for (let i = start; i <= end; i++) {
    await new Promise(resolve => setTimeout(resolve, 200));
    yield i;
  }
}

async function processNumbers() {
  const numbers = generateNumbers(1, 5);
  const remainingNumbers = numbers.drop(2);

  for await (const num of remainingNumbers) {
    console.log(num);
  }
}

processNumbers();

Prípad použitia v reálnom svete: Stránkovanie veľkého súboru dát získaného z API, pričom sa preskakujú už zobrazené výsledky.

async function* fetchData(url, pageSize, pageNumber) {
  const offset = (pageNumber - 1) * pageSize;
  // Simulácia načítania dát s posunom
  const data = [
    { id: 1, name: 'Item 1' },
    { id: 2, name: 'Item 2' },
    { id: 3, name: 'Item 3' },
    { id: 4, name: 'Item 4' },
    { id: 5, name: 'Item 5' },
    { id: 6, name: 'Item 6' },
    { id: 7, name: 'Item 7' },
    { id: 8, name: 'Item 8' }
  ];

  const pageData = data.slice(offset, offset + pageSize);

  for (const item of pageData) {
    await new Promise(resolve => setTimeout(resolve, 100));
    yield item;
  }
}

async function displayPage(pageNumber) {
  const pageSize = 3;
  const allData = fetchData('api/data', pageSize, pageNumber);
  const page = allData.drop((pageNumber - 1) * pageSize);  // preskočenie položiek z predchádzajúcich stránok

  const results = page.take(pageSize);


  for await (const item of results) {
    console.log(item);
  }
}

// Príklad použitia
displayPage(2);

5. `flatMap()`

Pomocník flatMap() transformuje každú hodnotu v asynchrónnej sekvencii použitím funkcie, ktorá vracia asynchrónny iterátor. Potom sploští výsledný asynchrónny iterátor do jedného asynchrónneho generátora. Je to užitočné na transformáciu každej hodnoty na prúd hodnôt a následné spojenie týchto prúdov.

Syntax:

asyncGenerator.flatMap(callback)

Príklad: Transformácia streamu viet na stream slov.

async function* generateSentences() {
  const sentences = [
    'This is the first sentence.',
    'This is the second sentence.',
    'This is the third sentence.'
  ];

  for (const sentence of sentences) {
    await new Promise(resolve => setTimeout(resolve, 200));
    yield sentence;
  }
}

async function* stringToWords(sentence) {
    const words = sentence.split(' ');
    for (const word of words) {
        await new Promise(resolve => setTimeout(resolve, 50));
        yield word;
    }
}

async function processSentences() {
  const sentences = generateSentences();
  const words = sentences.flatMap(async (sentence) => {
      return stringToWords(sentence);
  });

  for await (const word of words) {
    console.log(word);
  }
}

processSentences();

Prípad použitia v reálnom svete: Načítanie komentárov k viacerým blogovým príspevkom a ich spojenie do jedného streamu na spracovanie.

async function* fetchBlogPostIds() {
  const blogPostIds = [1, 2, 3]; // Simulácia načítania ID blogových príspevkov z API
  for (const id of blogPostIds) {
    await new Promise(resolve => setTimeout(resolve, 100));
    yield id;
  }
}

async function* fetchCommentsForPost(postId) {
  // Simulácia načítania komentárov k blogovému príspevku z API
  const comments = [
    { postId: postId, text: `Comment 1 for post ${postId}` },
    { postId: postId, text: `Comment 2 for post ${postId}` }
  ];
  for (const comment of comments) {
    await new Promise(resolve => setTimeout(resolve, 50));
    yield comment;
  }
}

async function processComments() {
  const postIds = fetchBlogPostIds();
  const allComments = postIds.flatMap(async (postId) => {
    return fetchCommentsForPost(postId);
  });

  for await (const comment of allComments) {
    console.log(comment);
  }
}

6. `reduce()`

Pomocník reduce() aplikuje funkciu na akumulátor a každú hodnotu asynchrónneho generátora (zľava doprava), aby ho zredukoval na jedinú hodnotu. Je to užitočné na agregáciu dát z asynchrónneho streamu.

Syntax:

asyncGenerator.reduce(callback, initialValue)

Príklad: Výpočet súčtu čísel v streame.

async function* generateNumbers(start, end) {
  for (let i = start; i <= end; i++) {
    await new Promise(resolve => setTimeout(resolve, 200));
    yield i;
  }
}

async function processNumbers() {
  const numbers = generateNumbers(1, 5);
  const sum = await numbers.reduce(async (accumulator, num) => {
    await new Promise(resolve => setTimeout(resolve, 100));
    return accumulator + num;
  }, 0);

  console.log('Sum:', sum);
}

processNumbers();

Prípad použitia v reálnom svete: Výpočet priemernej doby odozvy série volaní API.

async function* fetchResponseTimes(apiEndpoints) {
  for (const endpoint of apiEndpoints) {
    const startTime = Date.now();
    try {
      await fetch(endpoint);
      const endTime = Date.now();
      const responseTime = endTime - startTime;
      await new Promise(resolve => setTimeout(resolve, 50));
      yield responseTime;
    } catch (error) {
      console.error(`Error fetching ${endpoint}: ${error}`);
      yield 0; // Alebo ošetrite chybu primerane
    }
  }
}

async function calculateAverageResponseTime() {
  const apiEndpoints = [
    'https://api.example.com/endpoint1',
    'https://api.example.com/endpoint2',
    'https://api.example.com/endpoint3'
  ];
  const responseTimes = fetchResponseTimes(apiEndpoints);

  let count = 0;
  const sum = await responseTimes.reduce(async (accumulator, time) => {
    count++;
    return accumulator + time;
  }, 0);

  const average = count > 0 ? sum / count : 0;
  console.log(`Average response time: ${average} ms`);
}

7. `toArray()`

Pomocník toArray() spotrebuje asynchrónny generátor a vráti promise, ktorý sa vyrieši na pole obsahujúce všetky hodnoty poskytnuté generátorom. Je to užitočné, keď potrebujete zhromaždiť všetky hodnoty zo streamu do jedného poľa na ďalšie spracovanie.

Syntax:

asyncGenerator.toArray()

Príklad: Zbieranie čísel zo streamu do poľa.

async function* generateNumbers(start, end) {
  for (let i = start; i <= end; i++) {
    await new Promise(resolve => setTimeout(resolve, 200));
    yield i;
  }
}

async function processNumbers() {
  const numbers = generateNumbers(1, 5);
  const numberArray = await numbers.toArray();

  console.log('Number Array:', numberArray);
}

processNumbers();

Prípad použitia v reálnom svete: Zbieranie všetkých položiek zo stránkovaného API do jedného poľa pre filtrovanie alebo triedenie na strane klienta.

async function* fetchAllItems(apiEndpoint) {
    let pageNumber = 1;
    const pageSize = 100;  // Upravte podľa limitov stránkovania API

    while (true) {
        const url = `${apiEndpoint}?page=${pageNumber}&pageSize=${pageSize}`;
        const response = await fetch(url);
        const data = await response.json();

        if (!data || data.length === 0) {
            break; // Žiadne ďalšie dáta
        }

        for (const item of data) {
            await new Promise(resolve => setTimeout(resolve, 50));
            yield item;
        }

        pageNumber++;
    }
}

async function processAllItems() {
    const apiEndpoint = 'https://api.example.com/items';
    const allItems = fetchAllItems(apiEndpoint);
    const itemsArray = await allItems.toArray();

    console.log(`Fetched ${itemsArray.length} items.`);
    // Ďalšie spracovanie je možné vykonať na `itemsArray`
}

8. `forEach()`

Pomocník forEach() vykoná poskytnutú funkciu raz pre každú hodnotu v asynchrónnom generátore. Na rozdiel od iných pomocníkov, forEach() nevracia nový asynchrónny generátor; používa sa na vykonávanie vedľajších účinkov na každej hodnote.

Syntax:

asyncGenerator.forEach(callback)

Príklad: Zaznamenávanie každého čísla v streame do konzoly.

async function* generateNumbers(start, end) {
  for (let i = start; i <= end; i++) {
    await new Promise(resolve => setTimeout(resolve, 200));
    yield i;
  }
}

async function processNumbers() {
  const numbers = generateNumbers(1, 5);
  await numbers.forEach(async (num) => {
    await new Promise(resolve => setTimeout(resolve, 100));
    console.log('Number:', num);
  });
}

processNumbers();

Prípad použitia v reálnom svete: Posielanie aktualizácií v reálnom čase do používateľského rozhrania, keď sa dáta spracúvajú zo streamu.

async function* fetchRealTimeData(dataSource) {
    // Simulácia načítania dát v reálnom čase (napr. ceny akcií).
    const dataStream = [
      { timestamp: new Date(), price: 100 },
      { timestamp: new Date(), price: 101 },
      { timestamp: new Date(), price: 102 }
    ];
    for (const dataPoint of dataStream) {
      await new Promise(resolve => setTimeout(resolve, 500));
      yield dataPoint;
    }
}

async function updateUI() {
  const realTimeData = fetchRealTimeData('stock-api');
  await realTimeData.forEach(async (data) => {
    // Simulácia aktualizácie používateľského rozhrania
    await new Promise(resolve => setTimeout(resolve, 100));
    console.log(`Updating UI with data: ${JSON.stringify(data)}`);
    // Kód pre skutočnú aktualizáciu UI by bol tu.
  });
}

Kombinovanie pomocníkov pre komplexné dátové pipeline

Skutočná sila pomocníkov pre asynchrónne generátory spočíva v ich schopnosti byť reťazené dohromady na vytváranie komplexných dátových pipeline. To vám umožňuje vykonávať viacero transformácií a operácií na asynchrónnom streame stručným a čitateľným spôsobom.

Príklad: Filtrovanie streamu čísel, aby obsahoval iba párne čísla, potom ich umocnenie na druhú a nakoniec zobratie prvých 3 výsledkov.

async function* generateNumbers(start) {
  let i = start;
  while (true) {
    await new Promise(resolve => setTimeout(resolve, 100));
    yield i++;
  }
}

async function processNumbers() {
  const numbers = generateNumbers(1);

  const processedNumbers = numbers
    .filter(async (num) => num % 2 === 0)
    .map(async (num) => num * num)
    .take(3);

  for await (const num of processedNumbers) {
    console.log(num);
  }
}

processNumbers();

Prípad použitia v reálnom svete: Načítanie údajov o používateľoch, filtrovanie používateľov podľa ich polohy, transformácia ich údajov tak, aby obsahovali iba relevantné polia, a potom zobrazenie prvých 10 používateľov na mape.

async function* fetchUsers() {
  // Simulácia načítania používateľov z databázy alebo API
  const users = [
    { id: 1, name: 'John Doe', location: 'New York', email: 'john.doe@example.com' },
    { id: 2, name: 'Jane Smith', location: 'London', email: 'jane.smith@example.com' },
    { id: 3, name: 'Ken Tan', location: 'Singapore', email: 'ken.tan@example.com' },
    { id: 4, name: 'Alice Jones', location: 'New York', email: 'alice.jones@example.com' },
    { id: 5, name: 'Bob Williams', location: 'London', email: 'bob.williams@example.com' },
    { id: 6, name: 'Siti Rahman', location: 'Singapore', email: 'siti.rahman@example.com' },
    { id: 7, name: 'Ahmed Khan', location: 'Dubai', email: 'ahmed.khan@example.com' },
    { id: 8, name: 'Maria Garcia', location: 'Madrid', email: 'maria.garcia@example.com' },
    { id: 9, name: 'Li Wei', location: 'Shanghai', email: 'li.wei@example.com' },
    { id: 10, name: 'Hans Müller', location: 'Berlin', email: 'hans.muller@example.com' },
    { id: 11, name: 'Emily Chen', location: 'Sydney', email: 'emily.chen@example.com' }
  ];

  for (const user of users) {
    await new Promise(resolve => setTimeout(resolve, 50));
    yield user;
  }
}

async function displayUsersOnMap(location, maxUsers) {
  const users = fetchUsers();

  const usersForMap = users
    .filter(async (user) => user.location === location)
    .map(async (user) => ({
      id: user.id,
      name: user.name,
      location: user.location
    }))
    .take(maxUsers);

  console.log(`Displaying up to ${maxUsers} users from ${location} on the map:`);
  for await (const user of usersForMap) {
    console.log(user);
  }
}

// Príklady použitia:
displayUsersOnMap('New York', 2);
displayUsersOnMap('London', 5);

Polyfilly a podpora prehliadačov

Podpora pre pomocníkov asynchrónnych generátorov sa môže líšiť v závislosti od prostredia JavaScript. Ak potrebujete podporovať staršie prehliadače alebo prostredia, možno budete musieť použiť polyfilly. Polyfill poskytuje chýbajúcu funkcionalitu implementovaním v JavaScripte. K dispozícii je niekoľko knižníc polyfillov pre pomocníkov asynchrónnych generátorov, ako napríklad core-js.

Príklad použitia core-js:

// Importujte potrebné polyfilly
require('core-js/features/async-iterator/map');
require('core-js/features/async-iterator/filter');
// ... importujte ďalšie potrebné pomocné funkcie

Spracovanie chýb

Pri práci s asynchrónnymi operáciami je kľúčové správne spracovať chyby. S pomocníkmi pre asynchrónne generátory je možné spracovanie chýb vykonať pomocou blokov try...catch v rámci asynchrónnych funkcií použitých v pomocníkoch.

Príklad: Spracovanie chýb pri načítavaní dát v rámci operácie map().

async function* fetchData(urls) {
  for (const url of urls) {
    try {
      const response = await fetch(url);
      if (!response.ok) {
        throw new Error(`HTTP error! status: ${response.status}`);
      }
      const data = await response.json();
      yield data;
    } catch (error) {
      console.error(`Error fetching data from ${url}: ${error}`);
      yield null; // Alebo ošetrite chybu primerane, napr. vrátením chybového objektu
    }
  }
}

async function processData() {
  const urls = [
    'https://api.example.com/data1',
    'https://api.example.com/data2',
    'https://api.example.com/data3'
  ];

  const dataStream = fetchData(urls);

  const processedData = dataStream.map(async (data) => {
    if (data === null) {
      return null; // Prenesenie chyby ďalej
    }
    // Spracovanie dát
    return data;
  });

  for await (const item of processedData) {
    if (item === null) {
      console.log('Skipping item due to error');
      continue;
    }
    console.log('Processed Item:', item);
  }
}

processData();

Najlepšie postupy a úvahy

• Lenivé vyhodnocovanie: Pomocníci pre asynchrónne generátory sú vyhodnocovaní lenivo, čo znamená, že spracúvajú dáta iba vtedy, keď sú vyžiadané. To môže zlepšiť výkon, najmä pri práci s veľkými súbormi dát.
• Spracovanie chýb: Vždy správne spracujte chyby v rámci asynchrónnych funkcií použitých v pomocníkoch.
• Polyfilly: V prípade potreby použite polyfilly na podporu starších prehliadačov alebo prostredí.
• Čitateľnosť: Používajte popisné názvy premenných a komentáre, aby bol váš kód čitateľnejší a udržiavateľnejší.
• Výkon: Buďte si vedomí výkonnostných dôsledkov reťazenia viacerých pomocníkov. Hoci lenivosť pomáha, nadmerné reťazenie môže stále priniesť réžiu.

Záver

JavaScript Async Generator Helpers poskytujú výkonný a elegantný spôsob vytvárania, transformácie a správy asynchrónnych dátových streamov. Využitím týchto pomocníkov môžu vývojári písať stručnejší, čitateľnejší a udržiavateľnejší kód na spracovanie komplexných asynchrónnych operácií. Pochopenie základov asynchrónnych generátorov a iterátorov, spolu s funkcionalitami každého pomocníka, je nevyhnutné pre efektívne využitie týchto nástrojov v reálnych aplikáciách. Či už budujete dátové pipeline, spracúvate dáta v reálnom čase, alebo spracúvate asynchrónne odpovede API, pomocníci pre asynchrónne generátory môžu výrazne zjednodušiť váš kód a zlepšiť jeho celkovú efektivitu.